package com.qf.day11;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;

public class MyCollection<E> implements Collection<E> {
    /**
     * 用来存放集合中的元素的底层数组
     * 初始长度为10，可能会被扩容
     */
    private Object[] data = new Object[10];
    /**
     * (1)存放应该插入元素的位置
     * (2)同时这个变量也是集合中的元素的个数
     */
    private int count=0;
    @Override
    public int size() {
        return count;
    }

    @Override
    public boolean isEmpty() {
        return count==0;
    }

    @Override
    public boolean contains(Object o) {
        for (int i = 0; i < count; i++) {
            if (data.equals(o)) {
                return true;
            }
        }
        return false;
    }

    @Override
    public Iterator iterator() {
        return null;
    }

    @Override
    public Object[] toArray() {

        return Arrays.copyOf(data,count);
    }

    @Override
    public boolean add(E e) {
        // 如何保存传入的对象？
        // 放到数组的什么位置呢？ 声明一个实例变量，存放应该插入元素的位置
        // 同时这个变量也是集合中的元素的个数
        data[count++]=e;
        if(count==data.length){
            data=Arrays.copyOf(data,data.length*2);
        }
        return true;
    }

    @Override
    public boolean remove(Object o) {
        int index = getElementIndex(o);
        if(index==-1){
            return false;
        }else {
            System.arraycopy(data,index+1,data,index,count-(index-1));
            return true;
        }
    }

    private int getElementIndex(Object o) {
        for (int i = 0; i < count; i++) {
            if(data[i].equals(o)){
                return i;
            }
        }
        return -1;
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        for (Object o:c){
            if(!contains(o)){
                return false;
            }
        }
        return true;
    }

    @Override
    public void clear() {

        //data =new Object[10];
        for (int i = 0; i < count; i++) {
            data[i]=null;
        }
        count = 0;
    }

    @Override
    public boolean retainAll(Collection c) {
        //1. 遍历当前集合，判断应该删除的元素有哪些，把应该删除的元素放入一个集合中
        ArrayList<Object> list = new ArrayList<>();
        for (int i = 0; i < count; i++) {
            if (!c.contains(data[i])) {
                // 添加到删除集合中
                list.add(data[i]);
            }
        }

        //2. 删除上得到的集合中的所有元素
        return removeAll(list);

    }

    @Override
    public boolean removeAll(Collection c) {
        boolean flag = false;

        for (Object o : c) {
            if (remove(o)) {
                flag = true; // 当前集合已经成功删除一个元素，集合变化了
            }
        }

        return flag;
    }

    @Override
    public boolean containsAll(Collection c) {
        for (Object o : c) {
            // 只要有任何一个元素不再当前集合中，直接 return false
            if (!contains(o)) {
                return false;
            }
        }

        return true;
    }

    @Override
    public Object[] toArray(Object[] a) {
        System.arraycopy(data,0,a,0,count);
        return a;

    }
}
